local 游戏活动类 = class()

function 游戏活动类:初始化()
end

function 游戏活动类:设置文功题目(连接id, id)
	local 序列 = 取随机数(1, #官职答题题库)
	local 正确答案 = 官职答题题库[序列][2]
	local 随机答案 = {}

	for n = 2, #官职答题题库[序列] do
		随机答案[n - 1] = {
			答案 = 官职答题题库[序列][n],
			序列 = 取随机数(1, 9999)
		}
	end

	table.sort(随机答案, function (a, b)
		return b.序列 < a.序列
	end)

	local 显示答案 = {}

	for n = 1, #随机答案 do
		显示答案[n] = 随机答案[n].答案
	end

	玩家数据[id].角色.数据.文功任务.题目 = 玩家数据[id].角色.数据.文功任务.题目 + 1
	玩家数据[id].文功题目 = {
		题目 = 官职答题题库[序列][1],
		答案 = 显示答案,
		正确答案 = 正确答案
	}
	玩家数据[id].角色.数据.对话类型 = "文功答题"

	添加最后对话(id, format("#Y/我的难题：#W/%s", 玩家数据[id].文功题目.题目), 玩家数据[id].文功题目.答案)
end

function 游戏活动类:科举条件检测(连接id, id)
	if 科举数据[id] ~= nil and 科举数据[id].次数 >= 2 then
		常规提示(id, "你本日可参加科举活动的次数已经耗尽，请明日再来吧")

		return
	elseif 取等级(id) < 30 then
		常规提示(id, "只有等级达到30级的玩家才可参加科举活动")

		return
	end

	if 科举数据[id] == nil then
		科举数据[id] = {
			次数 = 0
		}
	end

	任务处理类:设置科举任务(id)

	科举数据[id].次数 = 科举数据[id].次数 + 1
	科举数据[id].天王令 = 1
	科举数据[id].地王令 = 2
	科举数据[id].鬼王令 = 3
	科举数据[id].答对 = 0
	科举数据[id].答错 = 0
	科举数据[id].总数 = 0
	科举数据[id].连对 = 0
	科举数据[id].起始 = os.time()

	self:设置科举题目(连接id, id)
end

function 游戏活动类:设置科举题目(连接id, id)
	local 序列 = 取随机数(1, #科举题库)
	local 正确答案 = 科举题库[序列][4]
	local 随机答案 = {}

	for n = 2, 4 do
		随机答案[n - 1] = {
			答案 = 科举题库[序列][n],
			序列 = 取随机数(1, 9999)
		}
	end

	table.sort(随机答案, function (a, b)
		return b.序列 < a.序列
	end)

	local 显示答案 = {}

	for n = 1, 3 do
		显示答案[n] = 随机答案[n].答案
	end

	显示答案[#显示答案 + 1] = "使用法宝"
	玩家数据[id].科举数据 = {
		题目 = 科举题库[序列][1],
		答案 = 显示答案,
		正确答案 = 正确答案
	}
	玩家数据[id].科举对话 = true
	科举数据[id].计时 = os.time()
	科举数据[id].总数 = 科举数据[id].总数 + 1

	发送数据(连接id, 1501, {
		名称 = "礼部侍郎",
		模型 = "考官2",
		对话 = format("#Y/第%s题：#W/%s", 科举数据[id].总数, 玩家数据[id].科举数据.题目),
		选项 = 玩家数据[id].科举数据.答案
	})
end

function 游戏活动类:科举回答题目(连接id, id, 答案, 类型)
	if 答案 == "使用法宝" then
		玩家数据[id].科举数据.题目 = "请选择你要使用的法宝："
		玩家数据[id].科举数据.答案 = {
			"天王令(得到正确作答，还可用" .. 科举数据[id].天王令 .. "次)",
			"地王令(系统作答，正确率50%,还可用" .. 科举数据[id].地王令 .. "次)",
			"鬼王令(战斗闯关，还可用" .. 科举数据[id].鬼王令 .. "次)"
		}

		发送数据(连接id, 1501, {
			名称 = "礼部侍郎",
			模型 = "考官2",
			对话 = 玩家数据[id].科举数据.题目,
			选项 = 玩家数据[id].科举数据.答案
		})

		玩家数据[id].科举数据.法宝使用 = true

		return
	end

	if 玩家数据[id].科举数据.法宝使用 then
		local 法宝序列 = 0

		for n = 1, 3 do
			if 答案 == 玩家数据[id].科举数据.答案[n] then
				法宝序列 = n
			end
		end

		if 法宝序列 == 0 then
			常规提示(id, "#Y/你没有这样的法宝")

			类型 = 9
		elseif 法宝序列 == 1 and 科举数据[id].天王令 <= 0 then
			常规提示(id, "#Y/你的这种法宝可用次数已经耗尽")

			类型 = 9
		elseif 法宝序列 == 2 and 科举数据[id].地王令 <= 0 then
			常规提示(id, "#Y/你的这种法宝可用次数已经耗尽")

			类型 = 9
		elseif 法宝序列 == 3 and 科举数据[id].鬼王令 <= 0 then
			常规提示(id, "#Y/你的这种法宝可用次数已经耗尽")

			类型 = 9
		else
			类型 = 法宝序列

			if 类型 == 3 then
				科举数据[id].鬼王令 = 科举数据[id].鬼王令 - 1

				常规提示(id, "#Y/你使用了鬼王令")

				玩家数据[id].科举数据.法宝使用 = nil

				战斗准备类:创建战斗(id, 100006, 0)

				return
			end
		end
	end

	玩家数据[id].科举数据.法宝使用 = nil
	local 正确 = false
	玩家数据[id].科举对话 = nil

	if 玩家数据[id].角色:取任务(7) == 0 and 类型 == nil then
		常规提示(id, "#Y/你没有这样的任务")

		return
	end

	if 类型 == nil then
		if os.time() - 科举数据[id].计时 <= 15 then
			if 答案 == 玩家数据[id].科举数据.正确答案 then
				正确 = true
			end
		else
			常规提示(id, "#Y/答题超时！")
		end
	elseif 类型 == 1 then
		正确 = true
		科举数据[id].天王令 = 科举数据[id].天王令 - 1

		常规提示(id, "#Y/你使用了天王令")
	elseif 类型 == 2 then
		if 取随机数() <= 50 then
			正确 = true
		end

		科举数据[id].地王令 = 科举数据[id].地王令 - 1

		常规提示(id, "#Y/你使用了地王令")
	elseif 类型 == 4 then
		正确 = true
	end

	if 正确 then
		科举数据[id].答对 = 科举数据[id].答对 + 1
		科举数据[id].连对 = 科举数据[id].连对 + 1

		if 科举数据[id].连对 >= 3 then
			科举数据[id].连对 = 0
			科举数据[id].鬼王令 = 科举数据[id].鬼王令 + 1

			常规提示(id, "#Y/连续答对三道题#R/鬼王令+1")
		end

		local 等级 = 取等级(id)
		local 经验 = 等级 * 20 * 2
		local 银子 = 等级 * 15 * 2

		玩家数据[id].角色:添加经验(经验, "科举活动", 1)
		玩家数据[id].角色:添加银子(银子, "科举活动", 1)

		local 奖励参数 = 取随机数(1, 500)

		if 类型 ~= nil then
			奖励参数 = 0
		end

		if 奖励参数 <= 20 then
			玩家数据[id].道具:给予道具(id, "藏宝图", 0)
			常规提示(id, "#Y/你获得了一张藏宝图")
		elseif 奖励参数 <= 30 then
			奖励名称[id] = 快捷给道具(id, 取强化石(), 取随机数(5, 10))

			广播消息({
				频道 = "xt",
				内容 = format("#S(科举活动)#R/%s#Y在科举活动中如有神助，妙笔生花，获得了考官奖励的#G/%s", 玩家数据[id].角色.数据.名称, 奖励名称[id])
			})
		elseif 奖励参数 <= 40 then
			奖励名称[id] = 快捷给道具(id, "神兜兜", 1)

			广播消息({
				频道 = "xt",
				内容 = format("#S(科举活动)#R/%s#Y在科举活动中如有神助，妙笔生花，获得了考官奖励的#G/%s", 玩家数据[id].角色.数据.名称, 奖励名称[id])
			})
		elseif 奖励参数 <= 50 then
			奖励名称[id] = 快捷给道具(id, "高级藏宝图", 1)

			广播消息({
				频道 = "xt",
				内容 = format("#S(科举活动)#R/%s#Y在科举活动中如有神助，妙笔生花，获得了考官奖励的#G/%s", 玩家数据[id].角色.数据.名称, 奖励名称[id])
			})
		elseif 奖励参数 <= 60 then
			奖励名称[id] = 快捷给道具(id, "金银锦盒", 取随机数(1, 5))
		end
	else
		科举数据[id].答错 = 科举数据[id].答错 + 1
		科举数据[id].连对 = 0

		常规提示(id, "#Y/你的回答不正确")
	end

	if 科举数据[id].总数 >= 20 then
		科举数据[id].耗时 = os.time() - 科举数据[id].起始

		if 科举数据[id].答对 >= 15 then
			local 等级 = 取等级(id)
			local 经验 = 等级 * 24 * 科举数据[id].答对
			local 储备 = 等级 * 10 * 科举数据[id].答对

			玩家数据[id].角色:添加经验(经验, "科举活动最终奖励", 1)
			玩家数据[id].角色:添加银子(储备, "科举活动最终奖励", 1)

			奖励名称[id] = 快捷给道具(id, "高级魔兽要诀", 1)

			广播消息({
				频道 = "xt",
				内容 = format("#S(科举活动)#R/%s#Y在科举活动的表现突出，仅用#W/%s#Y秒的时间就正确作答#W/%s#Y/道题目，因此获得了考官特别奖励的#G/%s", 玩家数据[id].角色.数据.名称, 科举数据[id].耗时, 科举数据[id].答对, "高级藏宝图")
			})
		end

		玩家数据[id].角色:取消任务(玩家数据[id].角色:取任务(7))
		常规提示(id, "#Y/恭喜你成功完成了本轮科举活动")

		玩家数据[id].科举数据 = nil
		活跃数据[id].活跃度 = 活跃数据[id].活跃度 + 2
		玩家数据[id].角色.数据.累积活跃.当前积分 = 玩家数据[id].角色.数据.累积活跃.当前积分 + 2
	elseif 科举数据[id].答错 >= 10 then
		科举数据[id].今日答题 = true

		玩家数据[id].角色:取消任务(玩家数据[id].角色:取任务(7))
		常规提示(id, "#Y/你当前累积错误题目数量已达10道，已经无法参加后续的活动了")

		玩家数据[id].科举数据 = nil
		活跃数据[id].活跃度 = 活跃数据[id].活跃度 + 2
		玩家数据[id].角色.数据.累积活跃.当前积分 = 玩家数据[id].角色.数据.累积活跃.当前积分 + 2
	else
		self:设置科举题目(连接id, id)
	end
end

function 游戏活动类:首席争霸战斗处理(胜利id, 失败id)
	local 门派 = ""
	self.战胜人数 = 1
	门派 = 玩家数据[失败id].角色.数据.门派
	首席争霸数据[门派][失败id].奖励 = true
	玩家数据[失败id].战斗 = 0

	常规提示(失败id, "等待首席争霸结束后可在首席争霸使者处领取奖励")
	地图处理类:跳转地图(失败id, 1001, 313, 85)

	self.添加积分 = self.战胜人数 * 5
	门派 = 玩家数据[胜利id].角色.数据.门派
	首席争霸数据[门派][胜利id].奖励 = true
	首席争霸数据[门派][胜利id].连胜次数 = 首席争霸数据[门派][胜利id].连胜次数 + 1

	if 首席争霸数据[门派][胜利id].连胜次数 == 5 then
		self.添加积分 = self.添加积分 + 5

		发送公告("#G无人可挡，玩家#R" .. 玩家数据[胜利id].角色.数据.名称 .. "#G在首席争霸赛中初获五连斩！！！")
	elseif 首席争霸数据[门派][胜利id].连胜次数 == 10 then
		self.添加积分 = self.添加积分 + 10

		发送公告("#G无人可挡，玩家#R" .. 玩家数据[胜利id].角色.数据.名称 .. "#G在首席争霸赛中十步杀一人，已获十连斩！！！")
	elseif 首席争霸数据[门派][胜利id].连胜次数 == 20 then
		self.添加积分 = self.添加积分 + 20

		发送公告("#G无人可挡，玩家#R" .. 玩家数据[胜利id].角色.数据.名称 .. "#G在首席争霸赛中杀人如麻，已获二十连斩！！！")
	elseif 首席争霸数据[门派][胜利id].连胜次数 == 30 then
		self.添加积分 = self.添加积分 + 30

		发送公告("#G无人可挡，玩家#R" .. 玩家数据[胜利id].角色.数据.名称 .. "#G在首席争霸赛中遇神杀神、遇魔杀魔，已获三十连战斩！！！")
	end

	首席争霸数据[门派][胜利id].积分 = 首席争霸数据[门派][胜利id].积分 + self.添加积分

	常规提示(胜利id, "你获得了" .. self.添加积分 .. "点首席争霸积分，当前总积分" .. 首席争霸数据[门派][胜利id].积分 .. "点")
end

function 游戏活动类:车迟回答题目(id, 答案, 任务id)
	local 正确 = false
	玩家数据[id].车迟对话 = nil

	if 玩家数据[id].角色:取任务(130) == 0 then
		常规提示(id, "#Y/你没有这样的任务")

		return
	end

	if 答案 == 玩家数据[id].车迟数据.正确答案 then
		正确 = true
	end

	if 正确 then
		快捷给道具(id, "普通木材", 1, nil, nil, 1)
		地图处理类:删除单位(任务数据[任务id].地图编号, 任务数据[任务id].单位编号)

		任务数据[任务id] = nil

		通用给奖励(id, {
			活跃度 = 1,
			经验 = {
				250,
				350
			},
			银子 = {
				100,
				150
			},
			储备 = {
				150,
				200
			}
		}, "车迟斗法1")
	else
		常规提示(id, "#Y/回答错误")
	end
end

function 游戏活动类:通天回答题目(id, 答案, 任务id)
	local 正确 = false
	玩家数据[id].通天对话 = nil

	if 玩家数据[id].角色:取任务(160) == 0 then
		常规提示(id, "#Y/你没有这样的任务")

		return
	end

	if 答案 == 玩家数据[id].通天数据.正确答案 then
		正确 = true
	end

	if 正确 == false then
		常规提示(id, "#Y/回答错误，叔叔小孩提出的问题你还能回答错误吗？可笑可笑！")
	end

	if 正确 then
		地图处理类:删除单位(任务数据[任务id].地图编号, 任务数据[任务id].单位编号)

		local 副本id = 任务数据[玩家数据[id].角色:取任务(160)].副本id
		副本数据.通天河.进行[副本id].通天答题 = 副本数据.通天河.进行[副本id].通天答题 + 1

		常规提示(id, "#Y/不错不错，答对了")
		通用给奖励(id, {
			活跃度 = 1,
			经验 = {
				250,
				350
			},
			银子 = {
				100,
				150
			},
			储备 = {
				150,
				200
			}
		}, "通天河1")

		任务数据[任务id] = nil

		if 副本数据.通天河.进行[副本id].通天答题 >= 5 then
			副本数据.通天河.进行[副本id].进程 = 2

			任务处理类:设置通天河副本(副本id)
		end

		for n = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
			if 队伍处理类:取是否助战(玩家数据[id].队伍, n) == 0 then
				玩家数据[队伍数据[玩家数据[id].队伍].成员数据[n]].角色:刷新任务跟踪()
			end
		end
	end
end

function 游戏活动类:炼丹更新()
	if 炼丹炉.时间 <= 0 then
		self.开奖数据 = self:炼丹开奖中()
	end

	炼丹炉.时间 = 炼丹炉.时间 - 1

	if 炼丹炉.时间 == 121 then
		self:炼丹开奖(self.开奖数据)
	end

	for i, v in pairs(炼丹查看) do
		if 玩家数据[i] ~= nil and 炼丹炉.时间 ~= nil then
			发送数据(玩家数据[i].连接id, 109, 炼丹炉.时间)
		else
			炼丹查看[i] = nil
		end
	end
end

function 游戏活动类:炼丹开奖中()
	local 八卦 = {
		"乾",
		"巽",
		"坎",
		"艮",
		"坤",
		"震",
		"离",
		"兑"
	}
	local 开奖 = {
		吉位 = 八卦[取随机数(1, #八卦)],
		八卦位 = 八卦[取随机数(1, #八卦)]
	}

	if 开奖.八卦位 == 开奖.吉位 then
		开奖.八卦位 = 八卦[取随机数(1, #八卦)]
	end

	for i, v in pairs(炼丹查看) do
		if 玩家数据[i] ~= nil then
			发送数据(玩家数据[i].连接id, 108.2, {
				吉位 = 开奖.吉位,
				八卦位 = 开奖.八卦位
			})
		else
			炼丹查看[i] = nil
		end
	end

	炼丹炉.时间 = 130

	return 开奖
end

function 游戏活动类:炼丹开奖(开奖)
	广播消息({
		频道 = "hd",
		内容 = "#S(八卦炼丹)#Y本次八卦炉炼丹结束,本次炼丹吉位为:#G" .. 开奖.吉位 .. " #Y本次炼丹八卦位为:#G" .. 开奖.八卦位
	})

	for i, v in pairs(炼丹炉) do
		if i ~= "时间" then
			if 炼丹炉[i][开奖.吉位] ~= nil and 炼丹炉[i][开奖.八卦位] ~= nil and 开奖.吉位 == 开奖.八卦位 then
				local 奖励数据 = {}
				奖励数据[1], 奖励数据[2], 奖励数据[3] = self:取奖励(炼丹炉[i][开奖.吉位])

				if 玩家数据[i] ~= nil then
					if 奖励数据[1] > 0 then
						玩家数据[i].道具:给予道具(i, "金砂丹", 奖励数据[1])
					end

					if 奖励数据[2] > 0 then
						玩家数据[i].道具:给予道具(i, "银砂丹", 奖励数据[2])
					end

					if 奖励数据[3] > 0 then
						玩家数据[i].道具:给予道具(i, "铜砂丹", 奖励数据[3])
					end

					常规提示(i, "#Y/恭喜你在炼丹中中得吉位和八卦位！")
					广播消息({
						频道 = "hd",
						内容 = string.format("#S(八卦炼丹)#Y恭喜:#G%s#Y在本次炼丹中幸运的猜中吉位以及八卦位获得了:#G%s颗#Y金丹 #G%s颗#Y银丹 #G%s颗#Y铜丹", 玩家数据[i].角色.数据.名称, 奖励数据[1], 奖励数据[2], 奖励数据[3])
					})
				elseif 商品存放[i] == nil then
					商品存放[i] = {
						奖励数据[1],
						奖励数据[2],
						奖励数据[3]
					}
				else
					商品存放[i] = {}
					商品存放[i][1] = 商品存放[i][1] + 奖励数据[1]
					商品存放[i][2] = 商品存放[i][2] + 奖励数据[2]
					商品存放[i][3] = 商品存放[i][3] + 奖励数据[3]
				end
			elseif 炼丹炉[i][开奖.吉位] ~= nil then
				local 奖励数据 = {}
				奖励数据[1], 奖励数据[2], 奖励数据[3] = self:取奖励(炼丹炉[i][开奖.吉位] / 2)
				奖励数据[1] = math.floor(奖励数据[1])
				奖励数据[2] = math.floor(奖励数据[2])
				奖励数据[3] = math.floor(奖励数据[3])

				if 玩家数据[i] ~= nil then
					if 奖励数据[1] > 0 then
						玩家数据[i].道具:给予道具(i, "金砂丹", 奖励数据[1])
					end

					if 奖励数据[2] > 0 then
						玩家数据[i].道具:给予道具(i, "银砂丹", 奖励数据[2])
					end

					if 奖励数据[3] > 0 then
						玩家数据[i].道具:给予道具(i, "铜砂丹", 奖励数据[3])
					end

					常规提示(i, "#Y/恭喜你在炼丹中中得吉位！")
					广播消息({
						频道 = "hd",
						内容 = string.format("#S(八卦炼丹)#Y恭喜:#G%s#Y在本次炼丹中幸运的猜中吉位获得了:#G%s颗#Y金丹 #G%s颗#Y银丹 #G%s颗#Y铜丹", 玩家数据[i].角色.数据.名称, 奖励数据[1], 奖励数据[2], 奖励数据[3])
					})
				elseif 商品存放[i] == nil then
					商品存放[i] = {
						奖励数据[1],
						奖励数据[2],
						奖励数据[3]
					}
				else
					商品存放[i] = {}
					商品存放[i][1] = 商品存放[i][1] + 奖励数据[1]
					商品存放[i][2] = 商品存放[i][2] + 奖励数据[2]
					商品存放[i][3] = 商品存放[i][3] + 奖励数据[3]
				end
			end
		end
	end

	炼丹炉 = {
		时间 = 120
	}

	for i, v in pairs(炼丹查看) do
		if 玩家数据[i] ~= nil then
			发送数据(玩家数据[i].连接id, 108.1, {
				数据 = 炼丹炉[i],
				灵气 = 玩家数据[i].角色.数据.炼丹灵气
			})
		else
			炼丹查看[i] = nil
		end
	end
end

function 游戏活动类:取奖励(信息)
	local 数组 = {
		0,
		0,
		0
	}

	if math.floor(信息 / 1000) > 0 then
		数组[1] = math.floor(信息 / 1000)
		信息 = 信息 - 数组[1] * 1000
		数组[2] = math.floor(信息 / 100)
		信息 = 信息 - 数组[2] * 100
		数组[3] = math.floor(信息 / 10)
	elseif math.floor(信息 / 100) > 0 then
		数组[2] = math.floor(信息 / 100)
		信息 = 信息 - 数组[2] * 100
		数组[3] = math.floor(信息 / 10)
	elseif math.floor(信息 / 10) > 0 then
		数组[3] = math.floor(信息 / 10)
	end

	return 数组[1], 数组[2], 数组[3]
end

function 游戏活动类:炼丹下注(内容)
	local 八卦 = {
		"乾",
		"巽",
		"坎",
		"艮",
		"坤",
		"震",
		"离",
		"兑"
	}
	local id = 内容.数字id
	local 序号 = 内容.编号
	local 数额 = 内容.数额

	if 炼丹炉.时间 <= 5 then
		常规提示(id, "#Y/即将开始炼丹,停止灌注灵气！")

		return
	elseif 炼丹炉.时间 >= 115 then
		常规提示(id, "#Y/炼丹才刚刚结束,请稍等再下注！")

		return
	elseif 玩家数据[id].角色.数据.炼丹灵气 < 数额 then
		常规提示(id, "#Y/你没有这么多的灵气用于灌注！")

		return
	elseif 数额 < 10 then
		常规提示(id, "#Y/炼丹炉单次灌注灵气不得少于10点！")

		return
	else
		if 炼丹炉[id] == nil then
			炼丹炉[id] = {
				[八卦[序号]] = 数额
			}
		elseif 炼丹炉[id][八卦[序号]] ~= nil then
			炼丹炉[id][八卦[序号]] = 炼丹炉[id][八卦[序号]] + 数额
		else
			炼丹炉[id][八卦[序号]] = 数额
		end

		玩家数据[id].角色.数据.炼丹灵气 = 玩家数据[id].角色.数据.炼丹灵气 - 数额

		常规提示(id, "#Y/灌注灵气成功,请等候丹炉炼丹吧！")
		发送数据(玩家数据[id].连接id, 108.1, {
			数据 = 炼丹炉[id],
			灵气 = 玩家数据[id].角色.数据.炼丹灵气
		})
	end
end

function 游戏活动类:开启剑会天下()
	剑会天下开关 = true

	广播消息({
		频道 = "xt",
		内容 = "#Y剑会天下活动已经开启#24,#Y/参加的玩家可以通过系统左上角PK按钮选择模式进行匹配战斗！"
	})
end

function 游戏活动类:关闭剑会天下()
	剑会天下开关 = false

	for n, v in pairs(剑会天下单人匹配) do
		if 玩家数据[v.id] ~= nil then
			发送数据(玩家数据[v.id].连接id, 128)
			常规提示(v.id, "#Y/剑会天下活动已经结束了！")
		end
	end

	剑会天下单人匹配 = {}

	for n, v in pairs(剑会天下三人匹配) do
		if 玩家数据[v.id].队伍 ~= 0 then
			for i = 1, #队伍数据[玩家数据[v.id].队伍].成员数据 do
				if 玩家数据[队伍数据[玩家数据[v.id].队伍].成员数据[i]] ~= nil then
					发送数据(玩家数据[队伍数据[玩家数据[v.id].队伍].成员数据[i]].连接id, 128)
					常规提示(队伍数据[玩家数据[v.id].队伍].成员数据[i], "#Y/剑会天下活动已经结束了！")
				end
			end
		end
	end

	剑会天下三人匹配 = {}

	for n, v in pairs(剑会天下五人匹配) do
		if 玩家数据[v.id].队伍 ~= 0 then
			for i = 1, #队伍数据[玩家数据[v.id].队伍].成员数据 do
				if 玩家数据[队伍数据[玩家数据[v.id].队伍].成员数据[i]] ~= nil then
					发送数据(玩家数据[队伍数据[玩家数据[v.id].队伍].成员数据[i]].连接id, 128)
					常规提示(队伍数据[玩家数据[v.id].队伍].成员数据[i], "#Y/剑会天下活动已经结束了！")
				end
			end
		end
	end

	剑会天下五人匹配 = {}

	广播消息({
		频道 = "xt",
		内容 = "#Y剑会天下活动结束啦#24,#Y/无法在进行匹配战斗了哦!"
	})
end

function 游戏活动类:剑会天下积分差异(胜利id, 失败id)
	local 胜利组平均分 = 0
	local 失败组平均分 = 0
	local 胜利基础分 = 40
	local 失败基础分 = 12
	local 分差值 = 0

	if 胜利id ~= 0 then
		if 玩家数据[胜利id].队伍 ~= 0 then
			local 队伍id = 玩家数据[胜利id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				胜利组平均分 = 胜利组平均分 + 剑会天下[队员id].当前积分
			end

			胜利组平均分 = math.floor(胜利组平均分 / #队伍数据[队伍id].成员数据)
		else
			胜利组平均分 = 剑会天下[胜利id].当前积分
		end
	end

	if 失败id ~= 0 then
		if 玩家数据[失败id].队伍 ~= 0 then
			local 队伍id = 玩家数据[失败id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				失败组平均分 = 失败组平均分 + 剑会天下[队员id].当前积分
			end

			失败组平均分 = math.floor(失败组平均分 / #队伍数据[队伍id].成员数据)
		else
			失败组平均分 = 剑会天下[失败id].当前积分
		end
	end

	if 胜利id == 0 then
		胜利组平均分 = 失败组平均分
	end

	if 失败id == 0 then
		失败组平均分 = 胜利组平均分
	end

	分差值 = 胜利组平均分 - 失败组平均分

	if 分差值 < 0 then
		if math.abs(分差值) > 100 then
			local 增加值 = math.floor(math.abs(分差值) / 100) * 2

			if 增加值 >= 10 then
				增加值 = 10
			end

			胜利基础分 = 胜利基础分 + 增加值
			失败基础分 = 失败基础分 + 增加值
		end
	elseif math.abs(分差值) > 100 then
		local 增加值 = math.floor(math.abs(分差值) / 100) * 2

		if 增加值 >= 10 then
			增加值 = 10
		end

		胜利基础分 = 胜利基础分 - 增加值
		失败基础分 = 失败基础分 - 增加值
	end

	return {
		胜利基础分,
		失败基础分
	}
end

function 游戏活动类:剑会天下奖励结算(id)
	if 剑会天下次数统计[id] == nil then
		剑会天下次数统计[id] = {
			首胜 = false,
			次数 = 0
		}
	end

	if 剑会天下次数统计[id].次数 <= 2 then
		剑会天下次数统计[id].次数 = 剑会天下次数统计[id].次数 + 1
	end

	if 剑会天下次数统计[id].首胜 == false then
		剑会天下次数统计[id].首胜 = true
	end

	if 剑会天下[id].连胜 == 3 then
		广播消息({
			频道 = "xt",
			内容 = format("#S(剑会天下)#Y/恭喜 #R/%s #Y在活动中连胜三场！获得#R5#仙玉", 玩家数据[id].角色.数据.名称)
		})
		添加仙玉(5, 玩家数据[id].账号, id, "比武战胜玩家")
	elseif 剑会天下[id].连胜 == 6 then
		广播消息({
			频道 = "xt",
			内容 = format("#S(剑会天下)#Y/恭喜 #R/%s #Y在活动中连胜六场！获得#R10#仙玉", 玩家数据[id].角色.数据.名称)
		})
		添加仙玉(10, 玩家数据[id].账号, id, "比武战胜玩家")
	elseif 剑会天下[id].连胜 == 9 then
		剑会天下[id].连胜 = 0

		广播消息({
			频道 = "xt",
			内容 = format("#S(剑会天下)#Y/恭喜 #R/%s #Y在活动中连胜九场！获得#R15#仙玉", 玩家数据[id].角色.数据.名称)
		})
		添加仙玉(15, 玩家数据[id].账号, id, "比武战胜玩家")
	end
end

function 游戏活动类:剑会天下结算处理假人(胜利id, 失败id)
	local 分差值 = self:剑会天下积分差异(胜利id, 失败id)

	if 胜利id ~= 0 and 剑会天下[胜利id] ~= nil then
		if 玩家数据[胜利id].队伍 ~= 0 then
			local 队伍id = 玩家数据[胜利id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				剑会天下[队员id].连胜 = 剑会天下[队员id].连胜 + 1
				剑会天下[队员id].当前积分 = 剑会天下[队员id].当前积分 + 分差值[1]
				local 临时数据 = 剑会天下[队员id]

				发送数据(玩家数据[队员id].连接id, 129, 临时数据)
				self:剑会天下奖励结算(队员id)
				添加仙玉(2, 玩家数据[队员id].账号, 队员id, "比武战胜玩家")
				常规提示(队员id, "#Y/你获得2仙玉")
			end
		else
			剑会天下[胜利id].连胜 = 剑会天下[胜利id].连胜 + 1
			剑会天下[胜利id].当前积分 = 剑会天下[胜利id].当前积分 + 分差值[1]
			local 临时数据 = 剑会天下[胜利id]

			发送数据(玩家数据[胜利id].连接id, 129, 临时数据)
			self:剑会天下奖励结算(胜利id)
			添加仙玉(2, 玩家数据[胜利id].账号, 胜利id, "比武战胜玩家")
			常规提示(胜利id, "#Y/你获得2仙玉")
		end
	end

	if 失败id ~= 0 and 剑会天下[失败id] ~= nil then
		if 玩家数据[失败id].队伍 ~= 0 then
			local 队伍id = 玩家数据[失败id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				剑会天下[队员id].连胜 = 0
				local 临时数据 = 剑会天下[队员id]

				发送数据(玩家数据[队员id].连接id, 129, 临时数据)
				self:剑会天下奖励结算(队员id)
				常规提示(队员id, "#Y/你输了")
			end
		else
			剑会天下[失败id].连胜 = 0
			local 临时数据 = 剑会天下[失败id]

			发送数据(玩家数据[失败id].连接id, 129, 临时数据)
			self:剑会天下奖励结算(失败id)
			常规提示(失败id, "#Y/你输了")
		end
	end
end

function 游戏活动类:剑会天下结算处理真人(胜利id, 失败id)
	local 分差值 = self:剑会天下积分差异(胜利id, 失败id)

	if 胜利id ~= 0 and 剑会天下[胜利id] ~= nil then
		if 玩家数据[胜利id].队伍 ~= 0 then
			local 队伍id = 玩家数据[胜利id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				剑会天下[队员id].连胜 = 剑会天下[队员id].连胜 + 1
				剑会天下[队员id].当前积分 = 剑会天下[队员id].当前积分 + 分差值[1]
				local 临时数据 = 剑会天下[队员id]

				发送数据(玩家数据[队员id].连接id, 129, 临时数据)
				self:剑会天下奖励结算(队员id)
				添加仙玉(3, 玩家数据[队员id].账号, 队员id, "比武战胜玩家")
				常规提示(队员id, "#Y/你获得3仙玉")
			end
		else
			剑会天下[胜利id].连胜 = 剑会天下[胜利id].连胜 + 1
			剑会天下[胜利id].当前积分 = 剑会天下[胜利id].当前积分 + 分差值[1]
			local 临时数据 = 剑会天下[胜利id]

			发送数据(玩家数据[胜利id].连接id, 129, 临时数据)
			self:剑会天下奖励结算(胜利id)
			添加仙玉(3, 玩家数据[胜利id].账号, 胜利id, "比武战胜玩家")
			常规提示(胜利id, "#Y/你获得3仙玉")
		end
	end

	if 失败id ~= 0 and 剑会天下[失败id] ~= nil then
		if 玩家数据[失败id].队伍 ~= 0 then
			local 队伍id = 玩家数据[失败id].队伍

			for n = 1, #队伍数据[队伍id].成员数据 do
				local 队员id = 队伍数据[队伍id].成员数据[n]
				剑会天下[队员id].连胜 = 0
				local 临时数据 = 剑会天下[队员id]

				发送数据(玩家数据[队员id].连接id, 129, 临时数据)
				self:剑会天下奖励结算(队员id)
				常规提示(队员id, "#Y/你输了")
			end
		else
			剑会天下[失败id].连胜 = 0
			local 临时数据 = 剑会天下[失败id]

			发送数据(玩家数据[失败id].连接id, 129, 临时数据)
			self:剑会天下奖励结算(失败id)
			常规提示(失败id, "#Y/你输了")
		end
	end
end

function 游戏活动类:比武大会战斗处理(胜利id, 失败id)
	广播消息({
		频道 = "xt",
		内容 = format("#G无人可挡，玩家#R" .. 玩家数据[胜利id].角色.数据.名称 .. "#G带领的队伍在英雄大会中战胜了#R" .. 玩家数据[失败id].角色.数据.名称 .. "#G带领的队伍")
	})

	local 分组 = ""

	if 玩家数据[失败id].队伍 == 0 then
		玩家数据[失败id].战斗 = 0
		比武大会.玩家表[失败id].失败次数 = 比武大会.玩家表[失败id].失败次数 + 1
		玩家数据[失败id].比武保护期 = os.time()

		if 比武大会.玩家表[失败id].失败次数 >= 3 then
			地图处理类:跳转地图(失败id, 1001, 124, 174)

			local 等级 = 玩家数据[失败id].角色.数据.等级
			local 经验 = qjy(等级) * 70
			local 银子 = qyz(等级) * 100 + qyz(等级)

			玩家数据[失败id].角色:添加经验(经验, "比武大会", 1)
			玩家数据[失败id].角色:添加银子(银子, "比武大会", 1)

			玩家数据[失败id].角色.数据.比武积分.当前积分 = 玩家数据[失败id].角色.数据.比武积分.当前积分 + 10

			添加仙玉(50, 玩家数据[失败id].账号, 失败id, "比武输给玩家")
			常规提示(失败id, "你已经#R失败3次#,被强制退出赛场,获得#G50点仙玉")
		end

		self:比武大会结算处理(比武大会.玩家表[失败id].地图, 比武大会.玩家表[失败id].小组)
	else
		self.战胜人数 = #队伍数据[玩家数据[失败id].队伍].成员数据

		for n = 1, #队伍数据[玩家数据[失败id].队伍].成员数据 do
			if 队伍处理类:取是否助战(玩家数据[失败id].队伍, n) == 0 then
				local 失败组id = 队伍数据[玩家数据[失败id].队伍].成员数据[n]
				玩家数据[失败组id].战斗 = 0
				比武大会.玩家表[失败组id].失败次数 = 比武大会.玩家表[失败组id].失败次数 + 1
				玩家数据[失败组id].比武保护期 = os.time()

				if 比武大会.玩家表[失败组id].失败次数 >= 3 then
					地图处理类:跳转地图(失败组id, 1001, 124, 174)

					local 等级 = 玩家数据[失败组id].角色.数据.等级
					local 经验 = qjy(等级) * 200
					local 银子 = qyz(等级) * 50 + qyz(等级)

					玩家数据[失败组id].角色:添加经验(经验, "比武大会", 1)
					玩家数据[失败组id].角色:添加银子(银子, "比武大会", 1)

					玩家数据[失败组id].角色.数据.比武积分.当前积分 = 玩家数据[失败组id].角色.数据.比武积分.当前积分 + 10

					添加仙玉(50, 玩家数据[失败组id].账号, 失败组id, "比武输给玩家")
					常规提示(失败组id, "你已经#R失败3次#,被强制退出赛场,获得#G50点仙玉")
				end
			end

			self:比武大会结算处理(比武大会.玩家表[失败id].地图, 比武大会.玩家表[失败id].小组)
		end
	end

	if 玩家数据[胜利id].队伍 == 0 then
		比武大会.本次积分[胜利id] = 比武大会.本次积分[胜利id] + 10
		玩家数据[胜利id].角色.数据.比武积分.当前积分 = 玩家数据[胜利id].角色.数据.比武积分.当前积分 + 10

		添加仙玉(50, 玩家数据[胜利id].账号, 胜利id, "比武战胜玩家")

		玩家数据[胜利id].比武保护期 = os.time()

		常规提示(胜利id, "你成功击败了对手，获得了50点仙玉")
	else
		for n = 1, #队伍数据[玩家数据[胜利id].队伍].成员数据 do
			if 队伍处理类:取是否助战(玩家数据[胜利id].队伍, n) == 0 then
				local 胜利组id = 队伍数据[玩家数据[胜利id].队伍].成员数据[n]
				比武大会.本次积分[胜利组id] = 比武大会.本次积分[胜利组id] + 10
				玩家数据[胜利组id].角色.数据.比武积分.当前积分 = 玩家数据[胜利组id].角色.数据.比武积分.当前积分 + 10

				添加仙玉(50, 玩家数据[胜利组id].账号, 胜利组id, "比武战胜玩家")

				玩家数据[胜利组id].比武保护期 = os.time()

				常规提示(胜利组id, "你成功击败了对手，获得了50点仙玉")
			end
		end
	end
end

function 游戏活动类:比武大会战斗失败处理(id)
	local id组 = {}

	if 玩家数据[id].队伍 == 0 then
		id组[1] = id
	else
		for n = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
			id组[n] = 队伍数据[玩家数据[id].队伍].成员数据[n]
		end
	end

	for n = 1, #id组 do
		local 等级 = 玩家数据[id组[n]].角色.数据.等级
		local 经验 = qjy(等级) * 500
		local 银子 = qyz(等级) * 100 + qyz(等级) * 比武大会.本次积分[id组[n]]

		玩家数据[id组[n]].角色:添加经验(经验, "比武大会", 1)
		玩家数据[id组[n]].角色:添加银子(银子, "比武大会", 1)
		地图处理类:跳转地图(id组[n], 1001, 116, 172)
		常规提示(id组[n], "由于你已经失去了继续比赛的资格，所以您已经将被强制传送出比赛地图")
	end

	self:比武大会结算处理(比武大会.玩家表[id].地图, 比武大会.玩家表[id].小组)
end

function 游戏活动类:比武大会中途退出(id)
	local id组 = {}

	if 玩家数据[id].队伍 == 0 then
		id组[1] = id
	else
		for n = 1, #队伍数据[玩家数据[id].队伍].成员数据 do
			id组[n] = 队伍数据[玩家数据[id].队伍].成员数据[n]
		end
	end

	for n = 1, #id组 do
		地图处理类:跳转地图(id组[n], 1001, 116, 172)
	end

	self:比武大会结算处理(比武大会.玩家表[id].地图, 比武大会.玩家表[id].小组)
end

function 游戏活动类:比武大会结算处理(地图, 小组)
	local 青龙数量 = 0
	local 白虎数量 = 0

	for n, v in pairs(地图处理类.地图玩家[地图]) do
		if 比武大会.玩家表[n] ~= nil then
			if 比武大会.玩家表[n].阵营 == "青龙" then
				青龙数量 = 青龙数量 + 1
			elseif 比武大会.玩家表[n].阵营 == "白虎" then
				白虎数量 = 白虎数量 + 1
			end
		else
			地图处理类:跳转地图(n, 1001, 116, 172)
		end
	end

	local 胜利阵营 = ""

	if 青龙数量 <= 0 then
		胜利阵营 = "白虎"
	elseif 白虎数量 <= 0 then
		胜利阵营 = "青龙"
	end

	if 胜利阵营 ~= "" and 比武大会[小组].胜利阵营 == nil then
		self:清除比武所有玩家(地图)

		比武大会.比赛 = false
		比武大会.入场 = false
		比武大会[小组].胜利阵营 = 胜利阵营

		广播消息({
			频道 = "xt",
			内容 = format("#R%s#W的比赛已经结束，#Y%s#W阵营获得了最终的胜利，该阵营的所有玩家现在可以去比武大会主持人处领取一次额外奖励了。该奖励领取的截止时间为明日的比武大会活动开启时间前。", 小组, 胜利阵营)
		})
	end
end

function 游戏活动类:清除比武胜利玩家(地图)
	for n, v in pairs(地图处理类.地图玩家[地图]) do
		local 等级 = 玩家数据[n].角色.数据.等级
		local 经验 = qjy(等级) * 1000
		local 银子 = qyz(等级) * 120 + qyz(等级) * 比武大会.本次积分[n] * 100

		玩家数据[n].角色:添加经验(经验, "比武大会", 1)
		玩家数据[n].角色:添加银子(银子, "比武大会", 1)
		地图处理类:跳转地图(n, 1001, 116, 172)
		常规提示(n, "由于你所在的小组比赛已经结束，所以您已经将被强制传送出比赛地图")
	end
end

function 游戏活动类:开启比武大会入场()
	比武开启 = os.time()
	比武大会.入场 = true
	比武大会.比赛 = false
	比武大会.精锐组 = {
		青龙 = {},
		白虎 = {}
	}
	比武大会.神威组 = {
		青龙 = {},
		白虎 = {}
	}
	比武大会.天科组 = {
		青龙 = {},
		白虎 = {}
	}
	比武大会.天元组 = {
		青龙 = {},
		白虎 = {}
	}
	比武大会.玩家表 = {}
	比武大会.本次积分 = {}

	任务处理类:刷出比武传送人()
end

function 游戏活动类:开启比武大会比赛()
	local 小组 = {
		"精锐组",
		"神威组",
		"天科组",
		"天元组"
	}
	local 小组地图 = {
		6003,
		6004,
		6005,
		6006
	}

	for i = 1, #小组 do
		local 统计数量 = 0

		for n, v in pairs(比武大会[小组[i]].青龙) do
			统计数量 = 统计数量 + 1
			比武大会.本次积分[n] = 0
		end

		for n, v in pairs(比武大会[小组[i]].白虎) do
			统计数量 = 统计数量 + 1
			比武大会.本次积分[n] = 0
		end

		if 统计数量 < 1 then
			广播消息({
				频道 = "xt",
				内容 = format("由于#Y%s#W参赛人员不足十人，因此天下比武大会中的#Y%s#W小组比赛已经被取消，场景内所在的玩家将被强制传送出场外", 小组[i], 小组[i])
			})
			self:强制清除玩家(小组地图[i], true)
		else
			地图处理类:当前消息广播1(小组地图[i], "#R本小组的比赛已经开始，你现在可以攻击对方阵营的玩家了")
		end
	end

	比武大会.比赛 = true
	比武大会.入场 = false
	比武大会.报名 = {}
end

function 游戏活动类:结束比武大会比赛(id)
	local 小组 = {
		"精锐组",
		"神威组",
		"天科组",
		"天元组"
	}
	local 小组地图 = {
		6003,
		6004,
		6005,
		6006
	}

	for n, v in pairs(战斗准备类.战斗盒子) do
		if 战斗准备类.战斗盒子[n].战斗类型 == 200004 then
			战斗准备类.战斗盒子[n]:结束战斗(0, 0, 1)
		end
	end

	for i = 1, #小组 do
		local 统计数量 = 0
		local 胜利阵营 = ""
		local 青龙人数 = 0
		local 白虎人数 = 0

		if 比武大会[小组[i]].胜利阵营 == nil then
			for n, v in pairs(地图处理类.地图玩家[小组地图[i]]) do
				if 比武大会.玩家表[n] ~= nil then
					if 比武大会.玩家表[n].阵营 == "青龙" then
						青龙人数 = 青龙人数 + 1
					elseif 比武大会.玩家表[n].阵营 == "白虎" then
						白虎人数 = 白虎人数 + 1
					end
				end

				if 玩家数据[n].战斗 ~= 0 then
				end
			end

			if 白虎人数 < 青龙人数 then
				胜利阵营 = "青龙"
			elseif 青龙人数 < 白虎人数 then
				胜利阵营 = "白虎"
			elseif 取随机数() <= 50 then
				胜利阵营 = "青龙"
			else
				胜利阵营 = "白虎"
			end

			self:清除比武所有玩家(小组地图[i], 阵营)

			比武大会[小组[i]].胜利阵营 = 胜利阵营

			广播消息({
				频道 = "xt",
				内容 = format("#R%s#W的比赛已经结束，#Y%s#W阵营获得了最终的胜利，该阵营的所有玩家现在可以去比武大会主持人处领取一次额外奖励了。该奖励领取的截止时间为明日的比武大会活动开启时间前。", 小组[i], 胜利阵营)
			})
		end
	end

	比武大会.比赛 = false
	比武大会.入场 = false
end

function 游戏活动类:清除比武所有玩家(地图, 阵营)
	for n, v in pairs(地图处理类.地图玩家[地图]) do
		if 比武大会.本次积分[n] == nil then
			比武大会.本次积分[n] = 1
		end

		if 比武大会.玩家表[n].阵营 == 阵营 then
			local 等级 = 玩家数据[n].角色.数据.等级
			local 经验 = qjy(等级) * 100
			local 银子 = qyz(等级) * 120 + qyz(等级) * 比武大会.本次积分[n] * 10

			玩家数据[n].角色:添加经验(经验, "比武大会", 1)
			玩家数据[n].角色:添加银子(银子, "比武大会", 1)
			地图处理类:跳转地图(n, 1001, 116, 172)
			常规提示(n, "由于你所在的小组比赛已经结束，所以您已经将被强制传送出比赛地图")
		else
			local 等级 = 玩家数据[n].角色.数据.等级
			local 经验 = qjy(等级) * 70
			local 银子 = qyz(等级) * 100 + qyz(等级) * 比武大会.本次积分[n] * 5

			玩家数据[n].角色:添加经验(经验, "比武大会", 1)
			玩家数据[n].角色:添加银子(银子, "比武大会", 1)
			地图处理类:跳转地图(n, 1001, 116, 172)
			常规提示(n, "由于你所在的小组比赛已经结束，所以您已经将被强制传送出比赛地图")
		end
	end
end

function 游戏活动类:强制清除玩家(地图, 补偿)
	for n, v in pairs(地图处理类.地图玩家[地图]) do
		for i = 1, #玩家数据[n].角色.数据.称谓 do
			if 玩家数据[n].角色.数据.称谓[i] == "白虎代表队成员" then
				玩家数据[n].角色:删除称谓(玩家数据[n].角色.数据.数字id, "白虎代表队成员")
			end

			if 玩家数据[n].角色.数据.称谓[i] == "青龙代表队成员" then
				玩家数据[n].角色:删除称谓(玩家数据[n].角色.数据.数字id, "青龙代表队成员")
			end
		end

		地图处理类:跳转地图(n, 1001, 116, 172)
		常规提示(n, "#W由于你所在的比武大会小组的参与人数低于10人，因此该小组的比赛已被取消")
	end
end

function 游戏活动类:比武大会入场事件(id)
	if 玩家数据[id].队伍 == 0 then
		if 玩家数据[id].角色.数据.等级 < 109 then
			添加最后对话(id, "你角色等级小于109级无法入场")

			return
		elseif 玩家数据[id].角色.数据.PK开关 ~= nil or 玩家数据[id].角色.数据.强P开关 ~= nil then
			添加最后对话(id, "无法携带强P状态入场！")

			return
		end

		local 入场信息 = self:取比武大会入场参数(id)

		if self:取比武大会分配状态(id) == false then
			local 阵营 = self:分配比武阵营(id, 入场信息[2])
			比武大会.玩家表[id] = {
				失败次数 = 0,
				小组 = 入场信息[2],
				阵营 = 阵营,
				地图 = 入场信息[1]
			}

			玩家数据[id].角色:添加称谓(id, 阵营 .. "代表队成员", "这是比武大会你所处阵营的身份标识")

			玩家数据[id].角色.当前称谓 = 阵营 .. "代表队成员"

			玩家数据[id].角色:更新称谓(id, 阵营 .. "代表队成员")
		end

		if 比武大会.玩家表[id].失败次数 == 5 then
			添加最后对话(id, "你已经在比武大会中累积失败5次，无法再进入比赛场地")

			return
		end

		local 临时yx = 地图处理类.地图坐标[入场信息[1]]:取随机点()

		地图处理类:跳转地图(id, 入场信息[1], 临时yx.x, 临时yx.y)
	else
		添加最后对话(id, "比武大赛禁止组队入场，请先退出队伍后再找我入场吧。")

		return
	end
end

function 游戏活动类:分配比武阵营(id, 小组, 指定阵营)
	if 指定阵营 ~= nil then
		比武大会[小组][指定阵营][id] = true

		return 指定阵营
	end

	local 阵营 = "青龙"
	local 青龙人数 = self:取比武大会阵营人数(小组, "青龙")
	local 白虎人数 = self:取比武大会阵营人数(小组, "白虎")

	if 白虎人数 < 青龙人数 then
		阵营 = "白虎"
	end

	比武大会[小组][阵营][id] = true

	return 阵营
end

function 游戏活动类:取比武大会阵营人数(小组, 阵营)
	local 人数 = 0

	for n, v in pairs(比武大会[小组][阵营]) do
		人数 = 人数 + 1
	end

	return 人数
end

function 游戏活动类:取比武大会分配状态(id)
	local 入场信息 = self:取比武大会入场参数(id)

	for n, v in pairs(比武大会[入场信息[2]].青龙) do
		if n == id then
			return true
		end
	end

	for n, v in pairs(比武大会[入场信息[2]].白虎) do
		if n == id then
			return true
		end
	end

	return false
end

function 游戏活动类:取比武大会入场参数(id)
	local 等级 = 玩家数据[id].角色.数据.等级

	if 等级 <= 69 then
		return {
			6003,
			"精锐组"
		}
	elseif 等级 <= 109 then
		return {
			6004,
			"神威组"
		}
	elseif 等级 <= 129 then
		return {
			6005,
			"天科组"
		}
	elseif 等级 > 129 then
		return {
			6006,
			"天元组"
		}
	end
end

function 游戏活动类:更新(dt)
end

function 游戏活动类:显示(x, y)
end

return 游戏活动类
